/**
 * 
 */
package ca.csf.dfc.poo.interfaceUtilisateur;

import java.util.Scanner;

import ca.csf.dfc.poo.engine.Engine;
import ca.csf.dfc.poo.environnement.Case;
import ca.csf.dfc.poo.environnement.Environnement;
import ca.csf.dfc.poo.environnement.Interdit;
import ca.csf.dfc.poo.environnement.Plancher;
import ca.csf.dfc.poo.environnement.Prise;
import ca.csf.dfc.poo.environnement.Robot;
import ca.csf.dfc.poo.environnement.RobotAleatoire;
import ca.csf.dfc.poo.environnement.RobotIntelligent;
import ca.csf.dfc.poo.environnement.RobotLineaire;
import ca.csf.dfc.poo.environnement.RobotVorace;
import ca.csf.dfc.poo.environnement.Tapis;
import ca.csf.dfc.poo.exceptions.IllegalPositionXException;
import ca.csf.dfc.poo.exceptions.IllegalPositionYException;
import ca.csf.dfc.poo.exceptions.IllegalRecompenseException;
import ca.csf.dfc.poo.exceptions.IllegalTableauDecisionException;
import ca.csf.dfc.poo.exceptions.InvalidDirectionException;

/**
 * @author Équipe 1
 *
 */
public class Main
{

	/**
	 * @param args
	 * @throws InvalidDirectionException 
	 * @throws IllegalRecompenseException 
	 * @throws IllegalPositionYException 
	 * @throws IllegalPositionXException 
	 * @throws IllegalTableauDecisionException 
	 */
	public static void main(String[] args) throws IllegalPositionXException, IllegalPositionYException, IllegalRecompenseException, InvalidDirectionException, IllegalTableauDecisionException
	{
	
		int nbRobot =-1; 
		int typeRobot = -1;
		int nbTours = 0;
		String maCarte;
		Scanner monScan = new Scanner(System.in);
		
		System.out.println("Bienvenue à la simulation des robots!");
		System.out.println("___________");
		System.out.println("|          |");
		System.out.println("|  _    _  |");
		System.out.println("| / \\  / \\ |");
		System.out.println("| |-|  |-| |");
		System.out.println("| ¯¯¯  ¯¯¯ |");
		System.out.println("| \\______/ |");
		System.out.println("|          |");
		System.out.println("¯¯¯¯¯¯¯¯¯¯¯¯");
		System.out.println("");
		System.out.println("");
		

		do{
			try
			{
				System.out.println("Entrez le nombre de robot pour la simulation");
				nbRobot =Integer.parseInt(monScan.nextLine());
			}
			catch(Exception exp)
			{
				
			}
		}while((nbRobot>10)||(nbRobot<0));
		
		int[] tabRobot= new int[nbRobot];
		
		for(int i = 0; i<nbRobot;i++)
		{
			monScan = new Scanner(System.in);
			do{
				try
				{
					System.out.println("Choisissez le type pour le robot "+i+": 1-Aléatoire, 2-Vorace, 3-Intelligent, 4-Linéaire");
					typeRobot=Integer.parseInt(monScan.nextLine());
				}
				catch(Exception exp)
				{
					
				}
			}while((typeRobot<1)||(typeRobot>4));
			tabRobot[i]=typeRobot;
			typeRobot = -1;
		}
		
		boolean valide = false;
		while(valide == false)
		{
			System.out.println("Entrez le nom de votre grille.");
			maCarte = monScan.nextLine();
	
			try
			{
				Engine nouveauEngine = new Engine(tabRobot,maCarte);
				valide = true;
				do
				{
					try
					{
					    //On affiche l'environnement
					    dessinerEnvironnement(nouveauEngine);
					    
						System.out.println("Entrez le nombre de déplacement à effectuer pour chaque robot (0 pour arrêter).");
						nbTours =Integer.parseInt(monScan.nextLine());
						if(nbTours > 0)
						{
							nouveauEngine.deplacerRobot(nbTours);
						}
						afficheResultats(nouveauEngine.getMesRobot());
					}
					catch(Exception exp)
					{
						
					}
				}while(nbTours!=0);
			}
				catch(Exception exp)
			{
				
			}
		}

		

	}
	
	/**
	 * Fonction qui affiche le type de robot, leur position ainsi que leur récompense.
	 * @param p_Robot Tableau contenant les robots utilisés
	 */
	public static void afficheResultats(Robot[] p_Robot)
	{
		//Compteur à robot
		int i = 1;
		
		//Boucle qui analyse le type de robot et affiche la position et leur récompense
		for(Robot a:p_Robot)
		{
			if(a instanceof RobotAleatoire)
			{
				System.out.println("Le robot "+ i + " est de type: Aleatoire");
			}
			if(a instanceof RobotLineaire)
			{
				System.out.println("Le robot "+ i + " est de type: Linéaire");
			}
			if(a instanceof RobotVorace)
			{
				System.out.println("Le robot "+ i + " est de type: Vorace");
			}
			
			if(a instanceof RobotIntelligent)
			{
				System.out.println("Le robot "+ i + " est de type: Intelligent");
			}
			System.out.println("Le robot est à la position "+ a.getX() + " , "+ a.getY());
			System.out.println("Il a accumulé " + a.getRecompense() + " points");
		}
	}
	
	/**
     * Fonction permet d'afficher à la console l'environnement.
     */
    public static void dessinerEnvironnement(Engine e)
    {
        Case[][] tabCases = e.getMonEnvironnement().getTableCase();
        Robot[] tabRobots = e.getMesRobot();
        
        String ligne = "";

        //Boucle pour les colonnes.
        for(int i = 0; i<tabCases[0].length;i++)
        {
            //Boucle pour les colonnes.
            for(int j = 0;j<tabCases.length;j++)
            {
                //On va chercher la case à la position ou on est rendu
                Case c = tabCases[j][i];
                
                //On regarde s'il y a un robot à la case où on est situé
                //Si oui, on le dissine à la place d'une case
                if (isRobot(j,i,tabRobots))
                {
                    ligne += "R";
                }
                //On choisi selon l'instance de la case, lequel des symbol on va dessiner.
                else if (c instanceof Interdit)
                {
                    ligne += "X";
                }
                else if (c instanceof Tapis)
                {
                    ligne += "t";
                }
                else if (c instanceof Prise)
                {
                    ligne += "P";
                }
                else if (c instanceof Plancher)
                {
                    ligne += " ";
                }
                
                //On regarde si on dessine le séparateur
                if (j < (tabCases.length-1))
                    ligne += " | ";
            }
            //On écrit la ligne (contient une rangé de cases)
            System.out.println(ligne);
            
            //On réinitialise la ligne et le séparateur
            ligne = "";
        }
    }
    
    /**
     * Fonction qui permet de dire s'il y a un robot dans le tableau.
     * @param p_X Position sur l'axe des X.
     * @param p_Y Position sur l'axe des Y.
     * @return True si un robot est à l'emplacement et false sinon.
     */
    public static boolean isRobot(int p_X, int p_Y, Robot[] p_TabRobots)
    {
        int i = 0;
        boolean present = false;
        
        while ((present == false) && (i<p_TabRobots.length))
        {
            if ((p_TabRobots[i].getX() == p_X) && (p_TabRobots[i].getY() == p_Y))
            {
                present = true;
            }
            
            i++;
        }
            
        return present;
    }
}
